Java之 |
您所在的位置：网站首页 › java comparator排序 › Java之 |
Java之
|
转载请注明出处：http://blog.csdn.net/l1028386804/article/details/56513205 一、需求假设现在有个如此的需求：需要对一个这样的雇员列表进行排序，排序规则如下： 1、首先级别最高的排在前面， 2、如果级别相等，那么按工资排序，工资高的排在前面， 3、如果工资相当则按入职年数排序，入职时间最长的排在前面。 雇员对象包含级别、工资和入职年份，代码如下： package com.lyz.sort.bean; import java.io.Serializable; /** * 雇员信息 * @author liuyazhuang * */ public class Employee implements Serializable { private static final long serialVersionUID = 4775629632953317597L; /** * ID */ public int id; /** * 级别 */ public int level; /** * 工资 */ public int salary; /** * 入职年数 */ public int year; public int getId() { return id; } public void setId(int id) { this.id = id; } public int getLevel() { return level; } public void setLevel(int level) { this.level = level; } public int getSalary() { return salary; } public void setSalary(int salary) { this.salary = salary; } public int getYear() { return year; } public void setYear(int year) { this.year = year; } public Employee(int id, int level, int salary, int year) { this.id = id; this.level = level; this.salary = salary; this.year = year; } } 二、实现Comparator接口这里我们实现Java.util.Comparator接口，用于对雇员列表进行排序，代码如下： package com.lyz.sort; import java.util.Comparator; import com.lyz.sort.bean.Employee; /** * 核心排序类 * @author liuyazhuang * */ public class EmpComparator implements Comparator { @Override public int compare(Employee employee1, Employee employee2) { int cr = 0; //按级别降序排列 int a = employee2.getLevel() - employee1.getLevel(); if (a != 0) { cr = (a > 0) ? 3 : -1; } else { //按薪水降序排列 a = employee2.getSalary() - employee1.getSalary(); if (a != 0) { cr = (a > 0) ? 2 : -2; } else { //按入职年数降序排列 a = employee2.getYear() - employee1.getYear(); if (a != 0) { cr = (a > 0) ? 1 : -3; } } } return cr; } } 三、验证排序结果下面用一个单元测试，来验证排序结果是否正确 package com.lyz.sort.test; import java.util.ArrayList; import java.util.Collections; import java.util.List; import org.junit.Test; import com.lyz.sort.EmpComparator; import com.lyz.sort.bean.Employee; /** * 测试排序类 * * @author liuyazhuang * */ public class SortTest { @Test public void sortTest() throws Exception { List employeeList = new ArrayList() { { add(new Employee(1, 9, 10000, 10)); add(new Employee(2, 9, 12000, 7)); add(new Employee(3, 5, 10000, 12)); add(new Employee(4, 5, 10000, 6)); add(new Employee(5, 3, 5000, 3)); add(new Employee(6, 1, 2500, 1)); add(new Employee(7, 5, 8000, 10)); add(new Employee(8, 3, 8000, 2)); add(new Employee(9, 1, 3000, 5)); add(new Employee(10, 1, 2500, 4)); add(new Employee(11, 2, 2000, 4)); } }; Collections.sort(employeeList, new EmpComparator()); System.out.println("ID\tLevel\tSalary\tYears"); System.out.println("============================="); for (Employee employee : employeeList) { System.out.printf("%d\t%d\t%d\t%d\n", employee.getId(), employee.getLevel(), employee.getSalary(), employee.getYear()); } System.out.println("============================="); } } 运行结果：
四、附录
java.util.Comparator接口源代码 /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package java.util; /** * A {@code Comparator} is used to compare two objects to determine their ordering with * respect to each other. On a given {@code Collection}, a {@code Comparator} can be used to * obtain a sorted {@code Collection} which is totally ordered. For a {@code Comparator} * to be consistent with equals, its {code #compare(Object, Object)} * method has to return zero for each pair of elements (a,b) where a.equals(b) * holds true. It is recommended that a {@code Comparator} implements * {@link java.io.Serializable}. * * @since 1.2 */ public interface Comparator { /** * Compares the two specified objects to determine their relative ordering. The ordering * implied by the return value of this method for all possible pairs of * {@code (lhs, rhs)} should form an equivalence relation. * This means that * * {@code compare(a,a)} returns zero for all {@code a} * the sign of {@code compare(a,b)} must be the opposite of the sign of {@code * compare(b,a)} for all pairs of (a,b) * From {@code compare(a,b) > 0} and {@code compare(b,c) > 0} it must * follow {@code compare(a,c) > 0} for all possible combinations of {@code * (a,b,c)} * * * @param lhs * an {@code Object}. * @param rhs * a second {@code Object} to compare with {@code lhs}. * @return an integer < 0 if {@code lhs} is less than {@code rhs}, 0 if they are * equal, and > 0 if {@code lhs} is greater than {@code rhs}. * @throws ClassCastException * if objects are not of the correct type. */ public int compare(T lhs, T rhs); /** * Compares this {@code Comparator} with the specified {@code Object} and indicates whether they * are equal. In order to be equal, {@code object} must represent the same object * as this instance using a class-specific comparison. ** A {@code Comparator} never needs to override this method, but may choose so for * performance reasons. * * @param object * the {@code Object} to compare with this comparator. * @return boolean {@code true} if specified {@code Object} is the same as this * {@code Object}, and {@code false} otherwise. * @see Object#hashCode * @see Object#equals */ public boolean equals(Object object); } |
【本文地址】
今日新闻 |
推荐新闻 |